package main

import (
	"crypto/md5"
	"encoding/base64"
	"encoding/hex"
	"fmt"

	"sort"
	"strings"

	"crypto/sha256"
)

// getKey 根据输入的字符串和指定方法返回加密/混淆后的字符串
func getKey(input string, method int) string {
	switch method {
	case 1:
		return get_key_md5_one(input) // 复杂Base64编码
	case 2:
		return get_key_md5_two(input) // 反转字符串
	case 3:
		return get_key_md5_three(input) // ROT13加密
	case 4:
		return get_key_md5_four(input) // 移位加密
	case 5:
		return get_key_md5_five(input) // 异或加密
	case 6:
		return get_key_md5_six(input) // 随机插入字符
	case 7:
		return get_key_md5_seven(input) // 大小写交换
	case 8:
		return get_key_md5_eight(input) // Base64加盐
	case 9:
		return get_key_md5_nine(input) // 双重反转
	case 10:
		return get_key_md5_ten(input) // MD5哈希
	case 11:
		return get_key_md5_eleven(input) // SHA-256哈希
	case 12:
		return get_key_md5_twelve(input) // Hex编码
	case 13:
		return get_key_md5_thirteen(input) // 镜像反转
	case 14:
		return get_key_md5_fourteen(input) // 字符串打乱
	case 15:
		return get_key_md5_fifteen(input) // 插入随机数字
	case 16:
		return get_key_md5_sixteen(input) // 去除空格
	case 17:
		return get_key_md5_seventeen(input) // 去除元音字母
	case 18:
		return get_key_md5_eighteen(input) // 交替大小写
	case 19:
		return get_key_md5_nineteen(input) // 复杂移位
	case 20:
		return get_key_md5_twenty(input) // 插入特殊字符
	case 21:
		return get_key_md5_twentyone(input) // 字符串乱序
	case 22:
		return get_key_md5_twentytwo(input) // 反转单词
	case 23:
		return get_key_md5_twentythree(input) // 重复单词
	case 24:
		return get_key_md5_twentyfour(input) // 混淆数字
	case 25:
		return get_key_md5_twentyfive(input) // Hex转二进制
	case 26:
		return get_key_md5_twentysix(input) // 随机大小写
	case 27:
		return get_key_md5_twentyseven(input) // 字符串压缩
	case 28:
		return get_key_md5_twentyeight(input) // 锯齿状移位
	case 29:
		return get_key_md5_twentynine(input) // 拆分并重组
	case 30:
		return get_key_md5_thirty(input) // 镜像反转加反转
	default:
		return input // 默认返回原始字符串
	}
}

// 通用 MD5 加密函数
func md5Encrypt(input string) string {
	hash := md5.Sum([]byte(input))
	return hex.EncodeToString(hash[:])
}

// 方法 1: 复杂 Base64 编码（带加盐）
func get_key_md5_one(input string) string {
	salt := "randomSalt123"
	concatenated := input + salt
	return md5Encrypt(base64.StdEncoding.EncodeToString([]byte(concatenated)))
}

// 方法 2: 字符串反转
func get_key_md5_two(input string) string {
	reversed := reverseString(input)
	return md5Encrypt(reversed)
}

// 方法 3: ROT13加密
func get_key_md5_three(input string) string {
	rot13 := applyRot13(input)
	return md5Encrypt(rot13)
}

// 方法 4: 移位加密
func get_key_md5_four(input string) string {
	shifted := shiftEncrypt(input, 5)
	return md5Encrypt(shifted)
}

// 方法 5: 按位异或加密
func get_key_md5_five(input string) string {
	xored := xorEncrypt(input, "key")
	return md5Encrypt(xored)
}

// 方法 6: 随机插入字符
func get_key_md5_six(input string) string {
	randomInserted := insertFixedChars(input)
	return md5Encrypt(randomInserted)
}

// 方法 7: 大小写交换
func get_key_md5_seven(input string) string {
	swapped := swapCase(input)
	return md5Encrypt(swapped)
}

// 方法 8: Base64加盐
func get_key_md5_eight(input string) string {
	saltedBase64 := base64WithSalt(input)

	return md5Encrypt(saltedBase64)
}

// 方法 9: 双重反转
func get_key_md5_nine(input string) string {
	doubleReversed := doubleReverse(input)
	return md5Encrypt(doubleReversed)
}

// 方法 10: MD5哈希
func get_key_md5_ten(input string) string {
	return md5Encrypt(input)
}

// 方法 11: SHA-256哈希
func get_key_md5_eleven(input string) string {
	hash := sha256Hash(input)
	return md5Encrypt(hash)
}

// 方法 12: Hex编码
func get_key_md5_twelve(input string) string {
	hexEncoded := hexEncode(input)
	return md5Encrypt(hexEncoded)
}

// 方法 13: 镜像反转
func get_key_md5_thirteen(input string) string {
	mirrored := mirrorString(input)
	return md5Encrypt(mirrored)
}

// 方法 14: 字符串打乱
func get_key_md5_fourteen(input string) string {
	shuffled := stringShuffle(input)
	return md5Encrypt(shuffled)
}

// 方法 15: 插入随机数字
func get_key_md5_fifteen(input string) string {
	randomNumbers := insertFixedNumbers(input)
	return md5Encrypt(randomNumbers)
}

// 方法 16: 去除空格
func get_key_md5_sixteen(input string) string {
	withoutSpaces := removeWhitespace(input)
	return md5Encrypt(withoutSpaces)
}

// 方法 17: 去除元音字母
func get_key_md5_seventeen(input string) string {
	withoutVowels := removeVowels(input)
	return md5Encrypt(withoutVowels)
}

// 方法 18: 交替大小写
func get_key_md5_eighteen(input string) string {
	alternated := alternateCase(input)
	return md5Encrypt(alternated)
}

// 方法 19: 复杂移位
func get_key_md5_nineteen(input string) string {
	shifted := complexShift(input)
	return md5Encrypt(shifted)
}

// 方法 20: 插入特殊字符
func get_key_md5_twenty(input string) string {
	withSpecialChars := insertSpecialChars(input)
	return md5Encrypt(withSpecialChars)
}

// 方法 21: 字符串乱序
func get_key_md5_twentyone(input string) string {
	scrambled := scrambledString(input)
	return md5Encrypt(scrambled)
}

// 方法 22: 反转单词顺序
func get_key_md5_twentytwo(input string) string {
	reversedWords := reverseWords(input)
	return md5Encrypt(reversedWords)
}

// 方法 23: 重复单词
func get_key_md5_twentythree(input string) string {
	repeatedWords := wordRepeat(input)
	return md5Encrypt(repeatedWords)
}

// 方法 24: 混淆数字
func get_key_md5_twentyfour(input string) string {
	obfuscatedDigits := obfuscateDigits(input)
	return md5Encrypt(obfuscatedDigits)
}

// 方法 25: Hex转二进制
func get_key_md5_twentyfive(input string) string {
	binary := hexToBinary(input)
	return md5Encrypt(binary)
}

// 方法 26: 随机大小写
func get_key_md5_twentysix(input string) string {
	caseShuffled := shuffleCase(input)
	return md5Encrypt(caseShuffled)
}

// 方法 27: 字符串压缩
func get_key_md5_twentyseven(input string) string {
	compressed := stringCompression(input)
	return md5Encrypt(compressed)
}

// 方法 28: 锯齿状移位
func get_key_md5_twentyeight(input string) string {
	zigzag := zigzagShift(input)
	return md5Encrypt(zigzag)
}

// 方法 29: 拆分并重组
func get_key_md5_twentynine(input string) string {
	splitRejoined := splitAndRejoin(input)
	return md5Encrypt(splitRejoined)
}

// 方法 30: 镜像反转加反转
func get_key_md5_thirty(input string) string {
	mirroredReversed := mirrorAndReverse(input)
	return md5Encrypt(mirroredReversed)
}

// 方法 1: 复杂 Base64 编码（带加盐）
func complexBase64(input string) string {
	salt := "randomSalt123"
	concatenated := input + salt
	return base64.StdEncoding.EncodeToString([]byte(concatenated))
}

// 方法 2: 字符串反转
func reverseString(input string) string {
	runes := []rune(input)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

// 方法 3: ROT13加密
func applyRot13(input string) string {
	var result []rune
	for _, r := range input {
		if r >= 'a' && r <= 'z' {
			result = append(result, 'a'+(r-'a'+13)%26)
		} else if r >= 'A' && r <= 'Z' {
			result = append(result, 'A'+(r-'A'+13)%26)
		} else {
			result = append(result, r)
		}
	}
	return string(result)
}

// 方法 4: 移位加密
func shiftEncrypt(input string, shift int) string {
	var result []rune
	for _, r := range input {
		result = append(result, r+rune(shift))
	}
	return string(result)
}

// 方法 5: 按位异或加密
func xorEncrypt(input, key string) string {
	keyLen := len(key)
	result := []rune(input)
	for i := 0; i < len(input); i++ {
		result[i] = rune(int(result[i]) ^ int(key[i%keyLen]))
	}
	return string(result)
}

// 方法 6: 随机插入字符 (移除随机性，插入固定字符)
func insertFixedChars(input string) string {
	var result string
	for _, c := range input {
		result += string(c)
		// 插入固定字符（例如 'A'）
		result += "A"
	}
	return result
}

// 方法 7: 大小写交换
func swapCase(input string) string {
	var result []rune
	for _, c := range input {
		if c >= 'a' && c <= 'z' {
			result = append(result, c-'a'+'A')
		} else if c >= 'A' && c <= 'Z' {
			result = append(result, c-'A'+'a')
		} else {
			result = append(result, c)
		}
	}
	return string(result)
}

// 方法 8: Base64加盐
func base64WithSalt(input string) string {
	salt := string([]rune{798, 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, 789, 789, 789, 789, 789, 789, 789, 1759, 1767, 1763, 1768, 1764})

	return base64.StdEncoding.EncodeToString([]byte(input + salt))
}

// 方法 9: 双重反转
func doubleReverse(input string) string {
	return reverseString(reverseString(input))
}

// 方法 10: MD5哈希
func md5Hash(input string) string {
	hash := md5.Sum([]byte(input))
	return hex.EncodeToString(hash[:])
}

// 方法 11: SHA-256哈希
func sha256Hash(input string) string {
	hash := sha256.Sum256([]byte(input))
	return hex.EncodeToString(hash[:])
}

// 方法 12: Hex编码
func hexEncode(input string) string {
	return hex.EncodeToString([]byte(input))
}

// 方法 13: 镜像反转
func mirrorString(input string) string {
	var result []rune
	for i := len(input) - 1; i >= 0; i-- {
		result = append(result, rune(input[i]))
	}
	return string(result)
}

// 方法 14: 字符串打乱 (移除随机性，按字母顺序排列)
func stringShuffle(input string) string {
	runes := []rune(input)
	sort.Slice(runes, func(i, j int) bool {
		return runes[i] < runes[j] // 按字母顺序排列
	})
	return string(runes)
}

// 方法 15: 插入随机数字 (移除随机性，插入固定数字)
func insertFixedNumbers(input string) string {
	var result string
	for _, c := range input {
		result += string(c)
		// 插入固定数字（例如 '5'）
		result += string([]rune{1761, 1765, 1764, 1764, 1760, 1768, 1768, 1764})
	}
	return result
}

// 方法 16: 去除空格
func removeWhitespace(input string) string {
	return strings.Join(strings.Fields(input), "")
}

// 方法 17: 去除元音字母
func removeVowels(input string) string {
	vowels := string([]rune{97, 101, 105, 111, 117, 65, 69, 73, 79, 85})
	var result string
	for _, c := range input {
		if !strings.ContainsRune(vowels, c) {
			result += string(c)
		}
	}
	return result
}

// 方法 18: 交替大小写
func alternateCase(input string) string {
	var result []rune
	for i, c := range input {
		if i%2 == 0 {
			result = append(result, c)
		} else {
			result = append(result, c)
		}
	}
	return string(result)
}

// 方法 19: 复杂移位
func complexShift(input string) string {
	var result []rune
	for i, r := range input {
		shift := 3 + i%5 // 每个字符的移位量不同
		result = append(result, r+rune(shift))
	}
	return string(result)
}

// 方法 20: 插入特殊字符 (移除随机性，插入固定特殊字符)
func insertSpecialChars(input string) string {
	specialChar := string([]rune{1798, 1765, 1764, 1764, 1760, 1768, 1768, 1764})
	var result string
	for _, c := range input {
		result += string(c)
		// 插入固定特殊字符
		result += specialChar
	}
	return result
}

// 方法 21: 字符串乱序 (移除随机性，按字母顺序排列)
func scrambledString(input string) string {
	runes := []rune(input)
	sort.Slice(runes, func(i, j int) bool {
		return runes[i] < runes[j] // 按字母顺序排列
	})
	return string(runes)
}

// 方法 22: 反转单词顺序
func reverseWords(input string) string {
	words := strings.Fields(input)
	for i, j := 0, len(words)-1; i < j; i, j = i+1, j-1 {
		words[i], words[j] = words[j], words[i]
	}
	return strings.Join(words, " ")
}

// 方法 23: 重复单词
func wordRepeat(input string) string {
	words := strings.Fields(input)
	var result string
	for _, word := range words {
		result += word + word + " "
	}
	return strings.TrimSpace(result)
}

// 方法 24: 混淆数字 (移除随机性，替换为固定数字)
func obfuscateDigits(input string) string {
	var result string
	for _, c := range input {
		if c >= '0' && c <= '9' {
			result += "1" // 替换为固定数字 '1'
		} else {
			result += string(c)
		}
	}
	return result
}

// 方法 25: Hex转二进制
func hexToBinary(input string) string {
	var result string
	for _, c := range input {
		result += fmt.Sprintf("%08b", c)
	}
	return result
}

// 方法 26: 随机大小写 (移除随机性，改为固定大小写)
func shuffleCase(input string) string {
	var result string
	for _, c := range input {
		result += strings.ToUpper(string(c)) // 将所有字符转换为大写
	}
	return result
}

// 方法 27: 字符串压缩
func stringCompression(input string) string {
	var result string
	for i := 0; i < len(input); i++ {
		count := 1
		for i+1 < len(input) && input[i] == input[i+1] {
			i++
			count++
		}
		result += fmt.Sprintf("%c%d", input[i], count)
	}
	return result
}

// 方法 28: 锯齿状移位
func zigzagShift(input string) string {
	var result []rune
	shift := 0
	for _, c := range input {
		result = append(result, c+rune(shift))
		shift = (shift + 1) % 3 // 以3为周期的移位
	}
	return string(result)
}

// 方法 29: 拆分并重组
func splitAndRejoin(input string) string {
	mid := len(input) / 2
	return input[mid:] + input[:mid]
}

// 方法 30: 镜像反转加反转
func mirrorAndReverse(input string) string {
	return reverseString(mirrorString(input))
}
